const APIError = require('../../rest_api').APIError;
const {RoleModel} = require('../../db/index');
const {isLogin} = require('../lib'); // 验证登录与角色

module.exports = {
    // 添加角色
    'POST /api/v1/role': async (ctx, next) => {
        const body = ctx.request.body;
        const token = ctx.headers.token;
        const name = body.name.trimAll();
        let article_type = body.article_type || 0;
        console.log(article_type);
        // 验证角色名称
        if (!name || name.length === 0) {
            throw new APIError('internal:role_name_error', '角色名称不能为空');
        }
        if(article_type != 0){
            article_type = true;
        }else{
            article_type = false;
        }
        console.log(article_type);
        // 验证登录与角色权限
        try {
            await isLogin(token, true, ['超级管理员']);
        } catch (error) {
            throw new APIError(error.code, error.message);
        }
        console.log(article_type);

        try {
            const data = await RoleModel.create({name,article_type});
            console.log(data);
            ctx.rest({
                message: '角色新建成功',
                data: {
                    name: data.name,
                    id: data.id
                }
            });
        } catch (error) {
            console.log('角色添加失败：', error);
            throw new APIError('internal:token_role_error', '角色添加失败');
        }

        await next();
    },
    // 获取角色/板块列表
    'GET /api/v1/role': async (ctx, next) => {
        let body = ctx.query;
        // 传入参数
        let count = parseFloat(body.count) || 10;
        let page = parseFloat(body.page) - 1 || 0;

        // 显示参数
        let needKey = {
            name: 1,
            upDate: 1
        };
        try {
            const dataCount = await RoleModel.find({}, needKey).count();
            const data = await RoleModel.find({}, needKey).limit(count).skip(page * count);

            // 返回数据
            ctx.rest({
                data,
                count: dataCount,
                page: page + 1
            });
        } catch (error) {
            throw new APIError('internal:comment_list_error', '获取角色列表失败');
        }
        await next();
    },
    // 修改角色/文章板块名称(请勿修改 管理员 与 超级管理员 的名称)
    'PUT /api/v1/role': async (ctx, next) => {
        const body = ctx.request.body;
        const id = body.id;
        const name = body.name.trimAll();
        const token = ctx.headers.token;

        if (!name || name.length === 0) {
            throw new APIError('internal:role_name_error', '请填写角色名称');
        }

        // 验证登录与角色权限
        try {
            await isLogin(token, true, ['超级管理员']);
        } catch (error) {
            throw new APIError(error.code, error.message);
        }
        // 验证是否存在此角色
        const queryRoleId = await RoleModel.findById(id);
        let nameArr = ['超级管理员','管理员'];
        if(nameArr.includes(queryRoleId.name)){
            throw new APIError('internal:role_error', `${nameArr.join()}的名称无法修改，修改失败`);
        }
        if (queryRoleId.name === '超级管理员' || queryRoleId.name === '管理员') {
            throw new APIError('internal:role_error', '超级管理与管理的名称无法修改，修改失败');
        }
        if (queryRoleId === null) {
            throw new APIError('internal:role_error', '此角色不存在，修改失败');
        }

        // 验证通过时
        try {
            await RoleModel.findByIdAndUpdate(id, {
                name,
                upDate: new Date()
            });
            // 返回数据
            ctx.rest({
                message: '修改成功'
            });
        } catch (error) {
            if (error.code === 11000) {
                throw new APIError('internal:role_name_repeat', '此角色名已存在，修改失败');
            } else {
                throw new APIError('internal:role_error', error.message);
            }
        }

        await next();
    },
    // 删除角色/文章板块
    'DELETE /api/v1/role': async (ctx, next) => {
        const body = ctx.request.body;
        const id = body.id;
        const token = ctx.headers.token;

        // 验证登录与角色权限
        try {
            await isLogin(token, true, ['超级管理员']);
        } catch (error) {
            throw new APIError(error.code, error.message);
        }
        // 验证是否存在此角色
        const queryRoleId = await RoleModel.findById(id);
        if (queryRoleId.name === '超级管理员') {
            throw new APIError('internal:role_error', '超级管理员无法删除，删除失败');
        }
        if (queryRoleId === null) {
            throw new APIError('internal:role_error', '此角色不存在，删除失败');
        }

        // 验证通过时
        try {
            await RoleModel.findOneAndRemove(id);
            // 返回数据
            ctx.rest({
                message: '删除成功'
            });
        } catch (error) {
            throw new APIError('internal:role_error', error.message);
        }
        await next();
    }
};
